package com.lottery.htbc.thread;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.lottery.htbc.dto.UserBetConfigDto;
import com.lottery.htbc.service.LuckDrawServiceImpl;
import com.lottery.htbc.utils.DateUtils;
import com.lottery.htbc.utils.FastJsonUtils;
import com.lottery.htbc.utils.service.redis.RedisService;

/**
 * 急速pk10
 *
 */
@SuppressWarnings("rawtypes")
public class LuckDrawJspkeRunnable extends LuckDrawBase implements Runnable {


	private final static Logger LOGGER = LoggerFactory.getLogger(LuckDrawJspkeRunnable.class);


	public LuckDrawJspkeRunnable(RedisService redisService,
			UserBetConfigDto betConfig,LuckDrawServiceImpl luckDrawService) {
		super(redisService, betConfig,luckDrawService);
		setRoomId(46);
	}


	//投注
	public  void  bettingJspk()throws Exception{
		if(!accountAhead()){
			return ;
		}
		Map roundMap=initGame();
		if(roundMap!=null){
			LOGGER.info("账户:{},游戏标识 [ {} ]游戏环境初始化完成============== ",betConfig.getAccount(),roundMap.get("id"));
			String round_id= roundMap.get("id").toString();
			String betStrInfo=redisService.get(betConfig.getAccount()+"_"+round_id);
			if(betStrInfo==null){
				Map<String ,Object> prarm=crateBettingParam();
				prarm.put("round_id",round_id);
				redisService.set(betConfig.getAccount()+"_"+round_id, FastJsonUtils.mapToJSONString(prarm),MINUTE*REPEAT_TIME);
				betting(prarm);
			}
			else{
				LOGGER.info("账户:{},游戏标识 [ {} ]重复投注=================重复投注   ",betConfig.getAccount(),roundMap.get("id"));
				LOGGER.info("\n");
			}


		}
	}

	//构造倍数 金额条件
	private Map crateBettingParam()throws Exception{
		calculationBei();
		Map<String ,Object> prarm=new HashMap<>();
		Map<String,Object> order=new HashMap<>();
		// 大双中的单
		//String balls=constructionValue(1,1);
		String balls=constructionRd();
		order.put("balls",balls);
		//注数
		int zhu=betConfig.getZhu();
		order.put("zhu",zhu);
		//模式
		float mode=betConfig.getMode();
		order.put("mode",mode);
		//计算倍数 基础倍数*权重
		int bei=BEISHUS[beiIndex]*betConfig.getPower();
		order.put("bei",bei);
		//模式 *单价 *倍数 *注数 *权重
		float money=mode*betConfig.getPrice()*bei*zhu;
		String moneyStr= String.format("%.2f", money);
		//金额
		order.put("money",moneyStr);
		order.put("type","dingwei");
		order.put("base",2);
		List<Map> orders=new ArrayList<>();
		orders.add(order);
		prarm.put("orders",orders);
		return prarm;
	}


	/**
	 * 倍数过期时间  48个小时
	 * 分钟
	 */
	private  static  final  int  BS_TIME=60*48;

	/**
	 * 手动设置基础倍数
	 */
	private static final  int[] beishus1={1,2,3,2,3,1,2,2,2,1,
		1,3,10,30,60,64,20,21,23,25,
		27,30,33,36,39,42,45,48,52,60};

	
	/**
	 * 倍数对应的下班<br/>  默认10(第11个数字)
	 */
	private  int beiIndex=10;
	/**
	 * 中奖第一次回调最大值下标
	 */
	private  static  final  int  BS_REBOUND_WIN_GRADE_1_MAX=13;
	/**
	 * 中奖第二次回调下标值(包含最大值不包含最小值)
	 */
	private  static  final  int  BS_REBOUND_WIN_GRADE_2_INDEX=16;
	/**
	 * 中奖第二次回调下最小值
	 */
	private  static  final  int  BS_REBOUND_WIN_GRADE_2_MIN=BS_REBOUND_WIN_GRADE_2_INDEX;
	/**
	 * 中奖第二次回调下最大值
	 */
	private  static  final  int  BS_REBOUND_WIN_GRADE_2_MAX=BS_REBOUND_WIN_GRADE_2_INDEX+4;

	/**
	 * 中奖第三次回调下标值(包含最大值不包含最小值)
	 */
	private  static  final  int  BS_REBOUND_WIN_GRADE_3_INDEX=22;
	/**
	 * 中奖第三次回调下最小值
	 */
	private  static  final  int  BS_REBOUND_WIN_GRADE_3_MIN=BS_REBOUND_WIN_GRADE_3_INDEX;
	/**
	 * 中奖第三次回调下最大值
	 */
	private  static  final  int  BS_REBOUND_WIN_GRADE_3_MAX=BS_REBOUND_WIN_GRADE_3_INDEX+4;
	/**
	 * 第一次不中奖回调 最小值
	 */
	private  static  final  int  BS_REBOUND_LOSE_GRADE_1_MIN=6;
	/**
	 * 第二次不中奖回调下标值(包含最小不包含最大)
	 */
	private  static  final  int  BS_REBOUND_LOSE_GRADE_2_INDEX=5;
	/**
	 * 第二次不中奖回调下最大值
	 */
	private  static  final  int  BS_REBOUND_LOSE_GRADE_2_MAX=BS_REBOUND_LOSE_GRADE_2_INDEX;
	/**
	 * 第二次不中奖回调下最小值
	 */
	private  static  final  int  BS_REBOUND_LOSE_GRADE_2_MIN=BS_REBOUND_LOSE_GRADE_2_MAX-3;
	
	/**
	 * 手动设置基础倍数
	 */
	private static final  int[] BEISHUS={1,1,2,2,2,1,1,2,3,4,
		5,12,24,48,60,64,1,3,10,30,
		60,64,4,8,16,32,64,67,70,70};

	private void calculationBei() throws Exception{
		String redisBsKey="HTBC_BS_INDEX_CURRENT_"+betConfig.getAccount();
		String bsStr=redisService.get(redisBsKey);
		if(bsStr!=null){
			int bs=Integer.valueOf(bsStr);
			if(isWinning()){
				//第一次 10到13(包含) 回归到10
				if(BS_REBOUND_WIN_GRADE_1_MAX>=bs&&bs>beiIndex){
					bs=beiIndex;
				}
				//第二次 17到20(包含)回归到16
				else if(BS_REBOUND_WIN_GRADE_2_MAX>=bs&&bs>BS_REBOUND_WIN_GRADE_2_MIN){
					bs=BS_REBOUND_WIN_GRADE_2_INDEX;
				}
				//第三次 23到26(包含)回归到22
				else if(BS_REBOUND_WIN_GRADE_3_MAX>=bs&&bs>BS_REBOUND_WIN_GRADE_3_MIN){
					bs=BS_REBOUND_WIN_GRADE_3_INDEX;
				}
				else{
					bs--;
				}
				if(bs<0){
					bs=0;
				}
			}
			else{
				//第一次 9到6(包含)回归到10
				if(beiIndex>bs&&bs>=BS_REBOUND_LOSE_GRADE_1_MIN){
					bs=beiIndex;
				}
				//第二次 2到4 回归到5
				else if(BS_REBOUND_LOSE_GRADE_2_MAX>bs&&bs>=BS_REBOUND_LOSE_GRADE_2_MIN){
					bs=BS_REBOUND_LOSE_GRADE_2_INDEX;
				}
				else{
					bs++;
				}
				if(bs>=BEISHUS.length){
					bs=BEISHUS.length-1;
				}
			}
			beiIndex=bs;
		}
		LOGGER.info("账户:{},当前倍数下标为:{},对应的基础倍数为:{},加权[{}]后的倍数为:{}",betConfig.getAccount(),beiIndex,BEISHUS[beiIndex],
				betConfig.getPower(),BEISHUS[beiIndex]*betConfig.getPower());
		redisService.set(redisBsKey,beiIndex+"",MINUTE*BS_TIME);
		//记录倍数下标流水
		String redisFlowKey="HTBC_BS_INDEX_FLOW_"+DateUtils.getDays()+"_"+betConfig.getAccount();
		String flowStr=redisService.get(redisFlowKey);
		if(flowStr!=null){
			flowStr+=","+beiIndex;
		}
		else{
			flowStr=""+beiIndex;
		}
		redisService.set(redisFlowKey,flowStr);
	}
	@Override
	public void run() {
		try {
			this.bettingJspk();
		} catch (Exception e) {
		}
	}

}
